/* A recursive-descent parser generated by peg 0.1.1 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define YYRULECOUNT 22
#line 21 "basic.leg"

# include <stdio.h>

  typedef struct line line;

  struct line
  {
    int	  number;
    int	  length;
    char *text;
  };

  line *lines= 0;
  int   numLines= 0;
  int   pc= -1, epc= -1;
  int   batch= 0;

  int nextline(char *buf, int max);

# define min(x, y) ((x) < (y) ? (x) : (y))

# define YY_INPUT(buf, result, max_size)	\
  {						\
    if ((pc >= 0) && (pc < numLines))		\
      {						\
        line *linep= lines+pc++;		\
        result= min(max_size, linep->length);	\
        memcpy(buf, linep->text, result);	\
      }						\
    else					\
      result= nextline(buf, max_size);		\
  }

  union value {
    int		  number;
    char	 *string;
    int		(*binop)(int lhs, int rhs);
  };

# define YYSTYPE union value

  int variables[26];

  void accept(int number, char *line);

  void save(char *name);
  void load(char *name);
  void type(char *name);

  int lessThan(int lhs, int rhs)	{ return lhs <  rhs; }
  int lessEqual(int lhs, int rhs)	{ return lhs <= rhs; }
  int notEqual(int lhs, int rhs)	{ return lhs != rhs; }
  int equalTo(int lhs, int rhs)		{ return lhs == rhs; }
  int greaterEqual(int lhs, int rhs)	{ return lhs >= rhs; }
  int greaterThan(int lhs, int rhs)	{ return lhs >  rhs; }

  int input(void);

  int stack[1024], sp= 0;

  char *help;

  void error(char *fmt, ...);
  int findLine(int n, int create);

#ifndef YY_MALLOC
#define YY_MALLOC(C, N)		malloc(N)
#endif
#ifndef YY_REALLOC
#define YY_REALLOC(C, P, N)	realloc(P, N)
#endif
#ifndef YY_FREE
#define YY_FREE(C, P)		free(P)
#endif
#ifndef YY_LOCAL
#define YY_LOCAL(T)	static T
#endif
#ifndef YY_ACTION
#define YY_ACTION(T)	static T
#endif
#ifndef YY_RULE
#define YY_RULE(T)	static T
#endif
#ifndef YY_PARSE
#define YY_PARSE(T)	T
#endif
#ifndef YYPARSE
#define YYPARSE		yyparse
#endif
#ifndef YYPARSEFROM
#define YYPARSEFROM	yyparsefrom
#endif
#ifndef YYRELEASE
#define YYRELEASE	yyrelease
#endif
#ifndef YY_BEGIN
#define YY_BEGIN	( yy->__begin= yy->__pos, 1)
#endif
#ifndef YY_END
#define YY_END		( yy->__end= yy->__pos, 1)
#endif
#ifdef YY_DEBUG
# define yyprintf(args)	fprintf args
#else
# define yyprintf(args)
#endif
#ifndef YYSTYPE
#define YYSTYPE	int
#endif
#ifndef YY_STACK_SIZE
#define YY_STACK_SIZE 128
#endif

#ifndef YY_BUFFER_SIZE
#define YY_BUFFER_SIZE 1024
#endif

#ifndef YY_PART

typedef struct _yycontext yycontext;
typedef void (*yyaction)(yycontext *yy, char *yytext, int yyleng);
typedef struct _yythunk { int begin, end;  yyaction  action;  struct _yythunk *next; } yythunk;

struct _yycontext {
  char     *__buf;
  int       __buflen;
  int       __pos;
  int       __limit;
  char     *__text;
  int       __textlen;
  int       __begin;
  int       __end;
  int       __textmax;
  yythunk  *__thunks;
  int       __thunkslen;
  int       __thunkpos;
  YYSTYPE   __;
  YYSTYPE  *__val;
  YYSTYPE  *__vals;
  int       __valslen;
#ifdef YY_CTX_MEMBERS
  YY_CTX_MEMBERS
#endif
};

#ifdef YY_CTX_LOCAL
#define YY_CTX_PARAM_	yycontext *yyctx,
#define YY_CTX_PARAM	yycontext *yyctx
#define YY_CTX_ARG_	yyctx,
#define YY_CTX_ARG	yyctx
#ifndef YY_INPUT
#define YY_INPUT(yy, buf, result, max_size)		\
  {							\
    int yyc= getchar();					\
    result= (EOF == yyc) ? 0 : (*(buf)= yyc, 1);	\
    yyprintf((stderr, "<%c>", yyc));			\
  }
#endif
#else
#define YY_CTX_PARAM_
#define YY_CTX_PARAM
#define YY_CTX_ARG_
#define YY_CTX_ARG
yycontext _yyctx; /* = { (char *)0, 0, 0, 0, (char *)0, 0, 0, 0, 0, (yythunk *)0, 0, 0, (YYSTYPE), (YYSTYPE *)0, (YYSTYPE *)0, 0 
#ifdef YY_CTX_MEMBERS
 , (YY_CTX_MEMBERS)0
#endif
 }; */

yycontext *yyctx= &_yyctx;
#ifndef YY_INPUT
#define YY_INPUT(buf, result, max_size)			\
  {							\
    int yyc= getchar();					\
    result= (EOF == yyc) ? 0 : (*(buf)= yyc, 1);	\
    yyprintf((stderr, "<%c>", yyc));			\
  }
#endif
#endif

YY_LOCAL(int) yyrefill(yycontext *yy)
{
  int yyn;
  while (yy->__buflen - yy->__pos < 512)
    {
      yy->__buflen *= 2;
      yy->__buf= (char *)YY_REALLOC(yy, yy->__buf, yy->__buflen);
    }
#ifdef YY_CTX_LOCAL
  YY_INPUT(yy, (yy->__buf + yy->__pos), yyn, (yy->__buflen - yy->__pos));
#else
  YY_INPUT((yy->__buf + yy->__pos), yyn, (yy->__buflen - yy->__pos));
#endif
  if (!yyn) return 0;
  yy->__limit += yyn;
  return 1;
}

YY_LOCAL(int) yymatchDot(yycontext *yy)
{
  if (yy->__pos >= yy->__limit && !yyrefill(yy)) return 0;
  ++yy->__pos;
  return 1;
}

YY_LOCAL(int) yymatchChar(yycontext *yy, int c)
{
  if (yy->__pos >= yy->__limit && !yyrefill(yy)) return 0;
  if ((unsigned char)yy->__buf[yy->__pos] == c)
    {
      ++yy->__pos;
      yyprintf((stderr, "  ok   yymatchChar(yy, %c) @ %s\n", c, yy->__buf+yy->__pos));
      return 1;
    }
  yyprintf((stderr, "  fail yymatchChar(yy, %c) @ %s\n", c, yy->__buf+yy->__pos));
  return 0;
}

YY_LOCAL(int) yymatchString(yycontext *yy, const char *s)
{
  int yysav= yy->__pos;
  while (*s)
    {
      if (yy->__pos >= yy->__limit && !yyrefill(yy)) return 0;
      if (yy->__buf[yy->__pos] != *s)
        {
          yy->__pos= yysav;
          return 0;
        }
      ++s;
      ++yy->__pos;
    }
  return 1;
}

YY_LOCAL(int) yymatchClass(yycontext *yy, unsigned char *bits)
{
  int c;
  if (yy->__pos >= yy->__limit && !yyrefill(yy)) return 0;
  c= (unsigned char)yy->__buf[yy->__pos];
  if (bits[c >> 3] & (1 << (c & 7)))
    {
      ++yy->__pos;
      yyprintf((stderr, "  ok   yymatchClass @ %s\n", yy->__buf+yy->__pos));
      return 1;
    }
  yyprintf((stderr, "  fail yymatchClass @ %s\n", yy->__buf+yy->__pos));
  return 0;
}

YY_LOCAL(void) yyDo(yycontext *yy, yyaction action, int begin, int end)
{
  while (yy->__thunkpos >= yy->__thunkslen)
    {
      yy->__thunkslen *= 2;
      yy->__thunks= (yythunk *)YY_REALLOC(yy, yy->__thunks, sizeof(yythunk) * yy->__thunkslen);
    }
  yy->__thunks[yy->__thunkpos].begin=  begin;
  yy->__thunks[yy->__thunkpos].end=    end;
  yy->__thunks[yy->__thunkpos].action= action;
  ++yy->__thunkpos;
}

YY_LOCAL(int) yyText(yycontext *yy, int begin, int end)
{
  int yyleng= end - begin;
  if (yyleng <= 0)
    yyleng= 0;
  else
    {
      while (yy->__textlen < (yyleng + 1))
	{
	  yy->__textlen *= 2;
	  yy->__text= (char *)YY_REALLOC(yy, yy->__text, yy->__textlen);
	}
      memcpy(yy->__text, yy->__buf + begin, yyleng);
    }
  yy->__text[yyleng]= '\0';
  return yyleng;
}

YY_LOCAL(void) yyDone(yycontext *yy)
{
  int pos;
  for (pos= 0;  pos < yy->__thunkpos;  ++pos)
    {
      yythunk *thunk= &yy->__thunks[pos];
      int yyleng= thunk->end ? yyText(yy, thunk->begin, thunk->end) : thunk->begin;
      yyprintf((stderr, "DO [%d] %p %s\n", pos, thunk->action, yy->__text));
      thunk->action(yy, yy->__text, yyleng);
    }
  yy->__thunkpos= 0;
}

YY_LOCAL(void) yyCommit(yycontext *yy)
{
  if ((yy->__limit -= yy->__pos))
    {
      memmove(yy->__buf, yy->__buf + yy->__pos, yy->__limit);
    }
  yy->__begin -= yy->__pos;
  yy->__end -= yy->__pos;
  yy->__pos= yy->__thunkpos= 0;
}

YY_LOCAL(int) yyAccept(yycontext *yy, int tp0)
{
  if (tp0)
    {
      fprintf(stderr, "accept denied at %d\n", tp0);
      return 0;
    }
  else
    {
      yyDone(yy);
      yyCommit(yy);
    }
  return 1;
}

YY_LOCAL(void) yyPush(yycontext *yy, char *text, int count)
{
  if (text) { }
  yy->__val += count;
  while (yy->__valslen <= yy->__val - yy->__vals)
    {
      long offset= yy->__val - yy->__vals;
      yy->__valslen *= 2;
      yy->__vals= (YYSTYPE *)YY_REALLOC(yy, yy->__vals, sizeof(YYSTYPE) * yy->__valslen);
      yy->__val= yy->__vals + offset;
    }
}
YY_LOCAL(void) yyPop(yycontext *yy, char *text, int count)   { if (text) { } yy->__val -= count; }
YY_LOCAL(void) yySet(yycontext *yy, char *text, int count)   { if (text) { } yy->__val[count]= yy->__; }

#endif /* YY_PART */

#define	YYACCEPT	yyAccept(yy, yythunkpos0)

YY_RULE(int) yy_digit(yycontext *yy); /* 22 */
YY_RULE(int) yy_CLOSE(yycontext *yy); /* 21 */
YY_RULE(int) yy_OPEN(yycontext *yy); /* 20 */
YY_RULE(int) yy_SLASH(yycontext *yy); /* 19 */
YY_RULE(int) yy_STAR(yycontext *yy); /* 18 */
YY_RULE(int) yy_factor(yycontext *yy); /* 17 */
YY_RULE(int) yy_MINUS(yycontext *yy); /* 16 */
YY_RULE(int) yy_term(yycontext *yy); /* 15 */
YY_RULE(int) yy_PLUS(yycontext *yy); /* 14 */
YY_RULE(int) yy_COMMA(yycontext *yy); /* 13 */
YY_RULE(int) yy_string(yycontext *yy); /* 12 */
YY_RULE(int) yy_EQUAL(yycontext *yy); /* 11 */
YY_RULE(int) yy_var(yycontext *yy); /* 10 */
YY_RULE(int) yy_var_list(yycontext *yy); /* 9 */
YY_RULE(int) yy_relop(yycontext *yy); /* 8 */
YY_RULE(int) yy_expression(yycontext *yy); /* 7 */
YY_RULE(int) yy_expr_list(yycontext *yy); /* 6 */
YY_RULE(int) yy_number(yycontext *yy); /* 5 */
YY_RULE(int) yy_CR(yycontext *yy); /* 4 */
YY_RULE(int) yy_statement(yycontext *yy); /* 3 */
YY_RULE(int) yy__(yycontext *yy); /* 2 */
YY_RULE(int) yy_line(yycontext *yy); /* 1 */

YY_ACTION(void) yy_6_relop(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_6_relop\n"));
  {
#line 155
   __.binop= equalTo; ;
  }
#undef yythunkpos
#undef yypos
#undef yy
}
YY_ACTION(void) yy_5_relop(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_5_relop\n"));
  {
#line 154
   __.binop= greaterThan; ;
  }
#undef yythunkpos
#undef yypos
#undef yy
}
YY_ACTION(void) yy_4_relop(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_4_relop\n"));
  {
#line 153
   __.binop= greaterEqual; ;
  }
#undef yythunkpos
#undef yypos
#undef yy
}
YY_ACTION(void) yy_3_relop(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_3_relop\n"));
  {
#line 152
   __.binop= lessThan; ;
  }
#undef yythunkpos
#undef yypos
#undef yy
}
YY_ACTION(void) yy_2_relop(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_2_relop\n"));
  {
#line 151
   __.binop= notEqual; ;
  }
#undef yythunkpos
#undef yypos
#undef yy
}
YY_ACTION(void) yy_1_relop(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_1_relop\n"));
  {
#line 150
   __.binop= lessEqual; ;
  }
#undef yythunkpos
#undef yypos
#undef yy
}
YY_ACTION(void) yy_1_string(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_1_string\n"));
  {
#line 148
   __.string = yytext; ;
  }
#undef yythunkpos
#undef yypos
#undef yy
}
YY_ACTION(void) yy_1_number(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_1_number\n"));
  {
#line 144
   __.number = atoi(yytext); ;
  }
#undef yythunkpos
#undef yypos
#undef yy
}
YY_ACTION(void) yy_1_var(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_1_var\n"));
  {
#line 142
   __.number = yytext[0] - 'a' ;
  }
#undef yythunkpos
#undef yypos
#undef yy
}
YY_ACTION(void) yy_1_factor(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define n yy->__val[-1]
#define v yy->__val[-2]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_1_factor\n"));
  {
#line 138
   __.number = variables[v.number] ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef n
#undef v
}
YY_ACTION(void) yy_3_term(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define r yy->__val[-1]
#define l yy->__val[-2]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_3_term\n"));
  {
#line 136
   __.number = l.number ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef r
#undef l
}
YY_ACTION(void) yy_2_term(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define r yy->__val[-1]
#define l yy->__val[-2]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_2_term\n"));
  {
#line 135
   l.number /= r.number ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef r
#undef l
}
YY_ACTION(void) yy_1_term(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define r yy->__val[-1]
#define l yy->__val[-2]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_1_term\n"));
  {
#line 134
   l.number *= r.number ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef r
#undef l
}
YY_ACTION(void) yy_4_expression(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define r yy->__val[-1]
#define l yy->__val[-2]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_4_expression\n"));
  {
#line 132
   __.number = l.number ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef r
#undef l
}
YY_ACTION(void) yy_3_expression(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define r yy->__val[-1]
#define l yy->__val[-2]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_3_expression\n"));
  {
#line 131
   l.number -= r.number ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef r
#undef l
}
YY_ACTION(void) yy_2_expression(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define r yy->__val[-1]
#define l yy->__val[-2]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_2_expression\n"));
  {
#line 130
   l.number += r.number ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef r
#undef l
}
YY_ACTION(void) yy_1_expression(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define r yy->__val[-1]
#define l yy->__val[-2]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_1_expression\n"));
  {
#line 129
   l.number = -l.number ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef r
#undef l
}
YY_ACTION(void) yy_2_var_list(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define v yy->__val[-1]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_2_var_list\n"));
  {
#line 125
   variables[v.number]= input(); ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef v
}
YY_ACTION(void) yy_1_var_list(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define v yy->__val[-1]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_1_var_list\n"));
  {
#line 124
   variables[v.number]= input(); ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef v
}
YY_ACTION(void) yy_5_expr_list(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define e yy->__val[-1]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_5_expr_list\n"));
  {
#line 121
   printf("\n"); ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef e
}
YY_ACTION(void) yy_4_expr_list(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define e yy->__val[-1]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_4_expr_list\n"));
  {
#line 118
   printf("%d", e.number); ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef e
}
YY_ACTION(void) yy_3_expr_list(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define e yy->__val[-1]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_3_expr_list\n"));
  {
#line 117
   printf("%s", e.string); ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef e
}
YY_ACTION(void) yy_2_expr_list(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define e yy->__val[-1]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_2_expr_list\n"));
  {
#line 116
   printf("%d", e.number); ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef e
}
YY_ACTION(void) yy_1_expr_list(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define e yy->__val[-1]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_1_expr_list\n"));
  {
#line 115
   printf("%s", e.string); ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef e
}
YY_ACTION(void) yy_16_statement(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define s yy->__val[-1]
#define v yy->__val[-2]
#define e yy->__val[-3]
#define e2 yy->__val[-4]
#define r yy->__val[-5]
#define e1 yy->__val[-6]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_16_statement\n"));
  {
#line 113
   fprintf(stderr, "%s", help); ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef s
#undef v
#undef e
#undef e2
#undef r
#undef e1
}
YY_ACTION(void) yy_15_statement(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define s yy->__val[-1]
#define v yy->__val[-2]
#define e yy->__val[-3]
#define e2 yy->__val[-4]
#define r yy->__val[-5]
#define e1 yy->__val[-6]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_15_statement\n"));
  {
#line 112
   system("ls *.bas"); ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef s
#undef v
#undef e
#undef e2
#undef r
#undef e1
}
YY_ACTION(void) yy_14_statement(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define s yy->__val[-1]
#define v yy->__val[-2]
#define e yy->__val[-3]
#define e2 yy->__val[-4]
#define r yy->__val[-5]
#define e1 yy->__val[-6]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_14_statement\n"));
  {
#line 111
   type(s.string); ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef s
#undef v
#undef e
#undef e2
#undef r
#undef e1
}
YY_ACTION(void) yy_13_statement(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define s yy->__val[-1]
#define v yy->__val[-2]
#define e yy->__val[-3]
#define e2 yy->__val[-4]
#define r yy->__val[-5]
#define e1 yy->__val[-6]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_13_statement\n"));
  {
#line 110
   load(s.string); ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef s
#undef v
#undef e
#undef e2
#undef r
#undef e1
}
YY_ACTION(void) yy_12_statement(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define s yy->__val[-1]
#define v yy->__val[-2]
#define e yy->__val[-3]
#define e2 yy->__val[-4]
#define r yy->__val[-5]
#define e1 yy->__val[-6]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_12_statement\n"));
  {
#line 109
   save(s.string); ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef s
#undef v
#undef e
#undef e2
#undef r
#undef e1
}
YY_ACTION(void) yy_11_statement(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define s yy->__val[-1]
#define v yy->__val[-2]
#define e yy->__val[-3]
#define e2 yy->__val[-4]
#define r yy->__val[-5]
#define e1 yy->__val[-6]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_11_statement\n"));
  {
#line 108
   exit(0); ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef s
#undef v
#undef e
#undef e2
#undef r
#undef e1
}
YY_ACTION(void) yy_10_statement(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define s yy->__val[-1]
#define v yy->__val[-2]
#define e yy->__val[-3]
#define e2 yy->__val[-4]
#define r yy->__val[-5]
#define e1 yy->__val[-6]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_10_statement\n"));
  {
#line 106
   pc= -1;  if (batch) exit(0); ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef s
#undef v
#undef e
#undef e2
#undef r
#undef e1
}
YY_ACTION(void) yy_9_statement(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define s yy->__val[-1]
#define v yy->__val[-2]
#define e yy->__val[-3]
#define e2 yy->__val[-4]
#define r yy->__val[-5]
#define e1 yy->__val[-6]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_9_statement\n"));
  {
#line 105
   pc= 0; ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef s
#undef v
#undef e
#undef e2
#undef r
#undef e1
}
YY_ACTION(void) yy_8_statement(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define s yy->__val[-1]
#define v yy->__val[-2]
#define e yy->__val[-3]
#define e2 yy->__val[-4]
#define r yy->__val[-5]
#define e1 yy->__val[-6]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_8_statement\n"));
  {
#line 104
   load(s.string);  pc= 0; ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef s
#undef v
#undef e
#undef e2
#undef r
#undef e1
}
YY_ACTION(void) yy_7_statement(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define s yy->__val[-1]
#define v yy->__val[-2]
#define e yy->__val[-3]
#define e2 yy->__val[-4]
#define r yy->__val[-5]
#define e1 yy->__val[-6]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_7_statement\n"));
  {
#line 103
   int i;  for (i= 0;  i < numLines;  ++i) printf("%5d %s", lines[i].number, lines[i].text); ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef s
#undef v
#undef e
#undef e2
#undef r
#undef e1
}
YY_ACTION(void) yy_6_statement(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define s yy->__val[-1]
#define v yy->__val[-2]
#define e yy->__val[-3]
#define e2 yy->__val[-4]
#define r yy->__val[-5]
#define e1 yy->__val[-6]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_6_statement\n"));
  {
#line 102
   while (numLines) accept(lines->number, "\n"); ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef s
#undef v
#undef e
#undef e2
#undef r
#undef e1
}
YY_ACTION(void) yy_5_statement(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define s yy->__val[-1]
#define v yy->__val[-2]
#define e yy->__val[-3]
#define e2 yy->__val[-4]
#define r yy->__val[-5]
#define e1 yy->__val[-6]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_5_statement\n"));
  {
#line 101
   epc= pc;  if ((pc= sp ? stack[--sp] : -1) < 0) error("no gosub"); ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef s
#undef v
#undef e
#undef e2
#undef r
#undef e1
}
YY_ACTION(void) yy_4_statement(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define s yy->__val[-1]
#define v yy->__val[-2]
#define e yy->__val[-3]
#define e2 yy->__val[-4]
#define r yy->__val[-5]
#define e1 yy->__val[-6]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_4_statement\n"));
  {
#line 99
   epc= pc;  if (sp < 1024) stack[sp++]= pc, pc= findLine(e.number, 0); else error("too many gosubs");
							  if (pc < 0) error("no such line"); ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef s
#undef v
#undef e
#undef e2
#undef r
#undef e1
}
YY_ACTION(void) yy_3_statement(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define s yy->__val[-1]
#define v yy->__val[-2]
#define e yy->__val[-3]
#define e2 yy->__val[-4]
#define r yy->__val[-5]
#define e1 yy->__val[-6]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_3_statement\n"));
  {
#line 98
   variables[v.number]= e.number; ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef s
#undef v
#undef e
#undef e2
#undef r
#undef e1
}
YY_ACTION(void) yy_2_statement(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define s yy->__val[-1]
#define v yy->__val[-2]
#define e yy->__val[-3]
#define e2 yy->__val[-4]
#define r yy->__val[-5]
#define e1 yy->__val[-6]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_2_statement\n"));
  {
#line 96
   epc= pc;  if ((pc= findLine(e.number, 0)) < 0) error("no such line"); ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef s
#undef v
#undef e
#undef e2
#undef r
#undef e1
}
YY_ACTION(void) yy_1_statement(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define s yy->__val[-1]
#define v yy->__val[-2]
#define e yy->__val[-3]
#define e2 yy->__val[-4]
#define r yy->__val[-5]
#define e1 yy->__val[-6]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_1_statement\n"));
  {
#line 94
   if (!r.binop(e1.number, e2.number)) yythunkpos= 0; ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef s
#undef v
#undef e
#undef e2
#undef r
#undef e1
}
YY_ACTION(void) yy_3_line(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define n yy->__val[-1]
#define s yy->__val[-2]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_3_line\n"));
  {
#line 91
   exit(0); ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef n
#undef s
}
YY_ACTION(void) yy_2_line(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define n yy->__val[-1]
#define s yy->__val[-2]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_2_line\n"));
  {
#line 90
   epc= pc;  error("syntax error"); ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef n
#undef s
}
YY_ACTION(void) yy_1_line(yycontext *yy, char *yytext, int yyleng)
{
 if (yy) { }
 if (yytext) { }
 if (yyleng) { }
#define n yy->__val[-1]
#define s yy->__val[-2]
#define __ yy->__
#define yypos yy->__pos
#define yythunkpos yy->__thunkpos
  yyprintf((stderr, "do yy_1_line\n"));
  {
#line 88
   accept(n.number, yytext); ;
  }
#undef yythunkpos
#undef yypos
#undef yy
#undef n
#undef s
}

YY_RULE(int) yy_digit(yycontext *yy)
{  int yypos0= yy->__pos, yythunkpos0= yy->__thunkpos;
  yyprintf((stderr, "%s\n", "digit"));  if (!yymatchClass(yy, (unsigned char *)"\000\000\000\000\000\000\377\003\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l1;
  yyprintf((stderr, "  ok   %s @ %s\n", "digit", yy->__buf+yy->__pos));
  return 1;
  l1:;	  yy->__pos= yypos0; yy->__thunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "digit", yy->__buf+yy->__pos));
  return 0;
}
YY_RULE(int) yy_CLOSE(yycontext *yy)
{  int yypos0= yy->__pos, yythunkpos0= yy->__thunkpos;
  yyprintf((stderr, "%s\n", "CLOSE"));  if (!yymatchChar(yy, ')')) goto l2;  if (!yy__(yy)) goto l2;
  yyprintf((stderr, "  ok   %s @ %s\n", "CLOSE", yy->__buf+yy->__pos));
  return 1;
  l2:;	  yy->__pos= yypos0; yy->__thunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "CLOSE", yy->__buf+yy->__pos));
  return 0;
}
YY_RULE(int) yy_OPEN(yycontext *yy)
{  int yypos0= yy->__pos, yythunkpos0= yy->__thunkpos;
  yyprintf((stderr, "%s\n", "OPEN"));  if (!yymatchChar(yy, '(')) goto l3;  if (!yy__(yy)) goto l3;
  yyprintf((stderr, "  ok   %s @ %s\n", "OPEN", yy->__buf+yy->__pos));
  return 1;
  l3:;	  yy->__pos= yypos0; yy->__thunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "OPEN", yy->__buf+yy->__pos));
  return 0;
}
YY_RULE(int) yy_SLASH(yycontext *yy)
{  int yypos0= yy->__pos, yythunkpos0= yy->__thunkpos;
  yyprintf((stderr, "%s\n", "SLASH"));  if (!yymatchChar(yy, '/')) goto l4;  if (!yy__(yy)) goto l4;
  yyprintf((stderr, "  ok   %s @ %s\n", "SLASH", yy->__buf+yy->__pos));
  return 1;
  l4:;	  yy->__pos= yypos0; yy->__thunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "SLASH", yy->__buf+yy->__pos));
  return 0;
}
YY_RULE(int) yy_STAR(yycontext *yy)
{  int yypos0= yy->__pos, yythunkpos0= yy->__thunkpos;
  yyprintf((stderr, "%s\n", "STAR"));  if (!yymatchChar(yy, '*')) goto l5;  if (!yy__(yy)) goto l5;
  yyprintf((stderr, "  ok   %s @ %s\n", "STAR", yy->__buf+yy->__pos));
  return 1;
  l5:;	  yy->__pos= yypos0; yy->__thunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "STAR", yy->__buf+yy->__pos));
  return 0;
}
YY_RULE(int) yy_factor(yycontext *yy)
{  int yypos0= yy->__pos, yythunkpos0= yy->__thunkpos;  yyDo(yy, yyPush, 2, 0);
  yyprintf((stderr, "%s\n", "factor"));
  {  int yypos7= yy->__pos, yythunkpos7= yy->__thunkpos;  if (!yy_var(yy)) goto l8;  yyDo(yy, yySet, -2, 0);  yyDo(yy, yy_1_factor, yy->__begin, yy->__end);  goto l7;
  l8:;	  yy->__pos= yypos7; yy->__thunkpos= yythunkpos7;  if (!yy_number(yy)) goto l9;  yyDo(yy, yySet, -1, 0);  goto l7;
  l9:;	  yy->__pos= yypos7; yy->__thunkpos= yythunkpos7;  if (!yy_OPEN(yy)) goto l6;  if (!yy_expression(yy)) goto l6;  if (!yy_CLOSE(yy)) goto l6;
  }
  l7:;	
  yyprintf((stderr, "  ok   %s @ %s\n", "factor", yy->__buf+yy->__pos));  yyDo(yy, yyPop, 2, 0);
  return 1;
  l6:;	  yy->__pos= yypos0; yy->__thunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "factor", yy->__buf+yy->__pos));
  return 0;
}
YY_RULE(int) yy_MINUS(yycontext *yy)
{  int yypos0= yy->__pos, yythunkpos0= yy->__thunkpos;
  yyprintf((stderr, "%s\n", "MINUS"));  if (!yymatchChar(yy, '-')) goto l10;  if (!yy__(yy)) goto l10;
  yyprintf((stderr, "  ok   %s @ %s\n", "MINUS", yy->__buf+yy->__pos));
  return 1;
  l10:;	  yy->__pos= yypos0; yy->__thunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "MINUS", yy->__buf+yy->__pos));
  return 0;
}
YY_RULE(int) yy_term(yycontext *yy)
{  int yypos0= yy->__pos, yythunkpos0= yy->__thunkpos;  yyDo(yy, yyPush, 2, 0);
  yyprintf((stderr, "%s\n", "term"));  if (!yy_factor(yy)) goto l11;  yyDo(yy, yySet, -2, 0);
  l12:;	
  {  int yypos13= yy->__pos, yythunkpos13= yy->__thunkpos;
  {  int yypos14= yy->__pos, yythunkpos14= yy->__thunkpos;  if (!yy_STAR(yy)) goto l15;  if (!yy_factor(yy)) goto l15;  yyDo(yy, yySet, -1, 0);  yyDo(yy, yy_1_term, yy->__begin, yy->__end);  goto l14;
  l15:;	  yy->__pos= yypos14; yy->__thunkpos= yythunkpos14;  if (!yy_SLASH(yy)) goto l13;  if (!yy_factor(yy)) goto l13;  yyDo(yy, yySet, -1, 0);  yyDo(yy, yy_2_term, yy->__begin, yy->__end);
  }
  l14:;	  goto l12;
  l13:;	  yy->__pos= yypos13; yy->__thunkpos= yythunkpos13;
  }  yyDo(yy, yy_3_term, yy->__begin, yy->__end);
  yyprintf((stderr, "  ok   %s @ %s\n", "term", yy->__buf+yy->__pos));  yyDo(yy, yyPop, 2, 0);
  return 1;
  l11:;	  yy->__pos= yypos0; yy->__thunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "term", yy->__buf+yy->__pos));
  return 0;
}
YY_RULE(int) yy_PLUS(yycontext *yy)
{  int yypos0= yy->__pos, yythunkpos0= yy->__thunkpos;
  yyprintf((stderr, "%s\n", "PLUS"));  if (!yymatchChar(yy, '+')) goto l16;  if (!yy__(yy)) goto l16;
  yyprintf((stderr, "  ok   %s @ %s\n", "PLUS", yy->__buf+yy->__pos));
  return 1;
  l16:;	  yy->__pos= yypos0; yy->__thunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "PLUS", yy->__buf+yy->__pos));
  return 0;
}
YY_RULE(int) yy_COMMA(yycontext *yy)
{  int yypos0= yy->__pos, yythunkpos0= yy->__thunkpos;
  yyprintf((stderr, "%s\n", "COMMA"));  if (!yymatchChar(yy, ',')) goto l17;  if (!yy__(yy)) goto l17;
  yyprintf((stderr, "  ok   %s @ %s\n", "COMMA", yy->__buf+yy->__pos));
  return 1;
  l17:;	  yy->__pos= yypos0; yy->__thunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "COMMA", yy->__buf+yy->__pos));
  return 0;
}
YY_RULE(int) yy_string(yycontext *yy)
{  int yypos0= yy->__pos, yythunkpos0= yy->__thunkpos;
  yyprintf((stderr, "%s\n", "string"));  if (!yymatchChar(yy, '"')) goto l18;  yyText(yy, yy->__begin, yy->__end);  {
#define yytext yy->__text
#define yyleng yy->__textlen
if (!(YY_BEGIN)) goto l18;
#undef yytext
#undef yyleng
  }
  l19:;	
  {  int yypos20= yy->__pos, yythunkpos20= yy->__thunkpos;  if (!yymatchClass(yy, (unsigned char *)"\377\377\377\377\373\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377")) goto l20;  goto l19;
  l20:;	  yy->__pos= yypos20; yy->__thunkpos= yythunkpos20;
  }  yyText(yy, yy->__begin, yy->__end);  {
#define yytext yy->__text
#define yyleng yy->__textlen
if (!(YY_END)) goto l18;
#undef yytext
#undef yyleng
  }  if (!yymatchChar(yy, '"')) goto l18;  if (!yy__(yy)) goto l18;  yyDo(yy, yy_1_string, yy->__begin, yy->__end);
  yyprintf((stderr, "  ok   %s @ %s\n", "string", yy->__buf+yy->__pos));
  return 1;
  l18:;	  yy->__pos= yypos0; yy->__thunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "string", yy->__buf+yy->__pos));
  return 0;
}
YY_RULE(int) yy_EQUAL(yycontext *yy)
{  int yypos0= yy->__pos, yythunkpos0= yy->__thunkpos;
  yyprintf((stderr, "%s\n", "EQUAL"));  if (!yymatchChar(yy, '=')) goto l21;  if (!yy__(yy)) goto l21;
  yyprintf((stderr, "  ok   %s @ %s\n", "EQUAL", yy->__buf+yy->__pos));
  return 1;
  l21:;	  yy->__pos= yypos0; yy->__thunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "EQUAL", yy->__buf+yy->__pos));
  return 0;
}
YY_RULE(int) yy_var(yycontext *yy)
{  int yypos0= yy->__pos, yythunkpos0= yy->__thunkpos;
  yyprintf((stderr, "%s\n", "var"));  yyText(yy, yy->__begin, yy->__end);  {
#define yytext yy->__text
#define yyleng yy->__textlen
if (!(YY_BEGIN)) goto l22;
#undef yytext
#undef yyleng
  }  if (!yymatchClass(yy, (unsigned char *)"\000\000\000\000\000\000\000\000\000\000\000\000\376\377\377\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l22;  yyText(yy, yy->__begin, yy->__end);  {
#define yytext yy->__text
#define yyleng yy->__textlen
if (!(YY_END)) goto l22;
#undef yytext
#undef yyleng
  }  if (!yy__(yy)) goto l22;  yyDo(yy, yy_1_var, yy->__begin, yy->__end);
  yyprintf((stderr, "  ok   %s @ %s\n", "var", yy->__buf+yy->__pos));
  return 1;
  l22:;	  yy->__pos= yypos0; yy->__thunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "var", yy->__buf+yy->__pos));
  return 0;
}
YY_RULE(int) yy_var_list(yycontext *yy)
{  int yypos0= yy->__pos, yythunkpos0= yy->__thunkpos;  yyDo(yy, yyPush, 1, 0);
  yyprintf((stderr, "%s\n", "var_list"));  if (!yy_var(yy)) goto l23;  yyDo(yy, yySet, -1, 0);  yyDo(yy, yy_1_var_list, yy->__begin, yy->__end);
  l24:;	
  {  int yypos25= yy->__pos, yythunkpos25= yy->__thunkpos;  if (!yy_COMMA(yy)) goto l25;  if (!yy_var(yy)) goto l25;  yyDo(yy, yySet, -1, 0);  yyDo(yy, yy_2_var_list, yy->__begin, yy->__end);  goto l24;
  l25:;	  yy->__pos= yypos25; yy->__thunkpos= yythunkpos25;
  }
  yyprintf((stderr, "  ok   %s @ %s\n", "var_list", yy->__buf+yy->__pos));  yyDo(yy, yyPop, 1, 0);
  return 1;
  l23:;	  yy->__pos= yypos0; yy->__thunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "var_list", yy->__buf+yy->__pos));
  return 0;
}
YY_RULE(int) yy_relop(yycontext *yy)
{  int yypos0= yy->__pos, yythunkpos0= yy->__thunkpos;
  yyprintf((stderr, "%s\n", "relop"));
  {  int yypos27= yy->__pos, yythunkpos27= yy->__thunkpos;  if (!yymatchString(yy, "<=")) goto l28;  if (!yy__(yy)) goto l28;  yyDo(yy, yy_1_relop, yy->__begin, yy->__end);  goto l27;
  l28:;	  yy->__pos= yypos27; yy->__thunkpos= yythunkpos27;  if (!yymatchString(yy, "<>")) goto l29;  if (!yy__(yy)) goto l29;  yyDo(yy, yy_2_relop, yy->__begin, yy->__end);  goto l27;
  l29:;	  yy->__pos= yypos27; yy->__thunkpos= yythunkpos27;  if (!yymatchChar(yy, '<')) goto l30;  if (!yy__(yy)) goto l30;  yyDo(yy, yy_3_relop, yy->__begin, yy->__end);  goto l27;
  l30:;	  yy->__pos= yypos27; yy->__thunkpos= yythunkpos27;  if (!yymatchString(yy, ">=")) goto l31;  if (!yy__(yy)) goto l31;  yyDo(yy, yy_4_relop, yy->__begin, yy->__end);  goto l27;
  l31:;	  yy->__pos= yypos27; yy->__thunkpos= yythunkpos27;  if (!yymatchChar(yy, '>')) goto l32;  if (!yy__(yy)) goto l32;  yyDo(yy, yy_5_relop, yy->__begin, yy->__end);  goto l27;
  l32:;	  yy->__pos= yypos27; yy->__thunkpos= yythunkpos27;  if (!yymatchChar(yy, '=')) goto l26;  if (!yy__(yy)) goto l26;  yyDo(yy, yy_6_relop, yy->__begin, yy->__end);
  }
  l27:;	
  yyprintf((stderr, "  ok   %s @ %s\n", "relop", yy->__buf+yy->__pos));
  return 1;
  l26:;	  yy->__pos= yypos0; yy->__thunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "relop", yy->__buf+yy->__pos));
  return 0;
}
YY_RULE(int) yy_expression(yycontext *yy)
{  int yypos0= yy->__pos, yythunkpos0= yy->__thunkpos;  yyDo(yy, yyPush, 2, 0);
  yyprintf((stderr, "%s\n", "expression"));
  {  int yypos34= yy->__pos, yythunkpos34= yy->__thunkpos;
  {  int yypos36= yy->__pos, yythunkpos36= yy->__thunkpos;  if (!yy_PLUS(yy)) goto l36;  goto l37;
  l36:;	  yy->__pos= yypos36; yy->__thunkpos= yythunkpos36;
  }
  l37:;	  if (!yy_term(yy)) goto l35;  yyDo(yy, yySet, -2, 0);  goto l34;
  l35:;	  yy->__pos= yypos34; yy->__thunkpos= yythunkpos34;  if (!yy_MINUS(yy)) goto l33;  if (!yy_term(yy)) goto l33;  yyDo(yy, yySet, -2, 0);  yyDo(yy, yy_1_expression, yy->__begin, yy->__end);
  }
  l34:;	
  l38:;	
  {  int yypos39= yy->__pos, yythunkpos39= yy->__thunkpos;
  {  int yypos40= yy->__pos, yythunkpos40= yy->__thunkpos;  if (!yy_PLUS(yy)) goto l41;  if (!yy_term(yy)) goto l41;  yyDo(yy, yySet, -1, 0);  yyDo(yy, yy_2_expression, yy->__begin, yy->__end);  goto l40;
  l41:;	  yy->__pos= yypos40; yy->__thunkpos= yythunkpos40;  if (!yy_MINUS(yy)) goto l39;  if (!yy_term(yy)) goto l39;  yyDo(yy, yySet, -1, 0);  yyDo(yy, yy_3_expression, yy->__begin, yy->__end);
  }
  l40:;	  goto l38;
  l39:;	  yy->__pos= yypos39; yy->__thunkpos= yythunkpos39;
  }  yyDo(yy, yy_4_expression, yy->__begin, yy->__end);
  yyprintf((stderr, "  ok   %s @ %s\n", "expression", yy->__buf+yy->__pos));  yyDo(yy, yyPop, 2, 0);
  return 1;
  l33:;	  yy->__pos= yypos0; yy->__thunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "expression", yy->__buf+yy->__pos));
  return 0;
}
YY_RULE(int) yy_expr_list(yycontext *yy)
{  int yypos0= yy->__pos, yythunkpos0= yy->__thunkpos;  yyDo(yy, yyPush, 1, 0);
  yyprintf((stderr, "%s\n", "expr_list"));
  {  int yypos43= yy->__pos, yythunkpos43= yy->__thunkpos;
  {  int yypos45= yy->__pos, yythunkpos45= yy->__thunkpos;  if (!yy_string(yy)) goto l46;  yyDo(yy, yySet, -1, 0);  yyDo(yy, yy_1_expr_list, yy->__begin, yy->__end);  goto l45;
  l46:;	  yy->__pos= yypos45; yy->__thunkpos= yythunkpos45;  if (!yy_expression(yy)) goto l43;  yyDo(yy, yySet, -1, 0);  yyDo(yy, yy_2_expr_list, yy->__begin, yy->__end);
  }
  l45:;	  goto l44;
  l43:;	  yy->__pos= yypos43; yy->__thunkpos= yythunkpos43;
  }
  l44:;	
  l47:;	
  {  int yypos48= yy->__pos, yythunkpos48= yy->__thunkpos;  if (!yy_COMMA(yy)) goto l48;
  {  int yypos49= yy->__pos, yythunkpos49= yy->__thunkpos;  if (!yy_string(yy)) goto l50;  yyDo(yy, yySet, -1, 0);  yyDo(yy, yy_3_expr_list, yy->__begin, yy->__end);  goto l49;
  l50:;	  yy->__pos= yypos49; yy->__thunkpos= yythunkpos49;  if (!yy_expression(yy)) goto l48;  yyDo(yy, yySet, -1, 0);  yyDo(yy, yy_4_expr_list, yy->__begin, yy->__end);
  }
  l49:;	  goto l47;
  l48:;	  yy->__pos= yypos48; yy->__thunkpos= yythunkpos48;
  }
  {  int yypos51= yy->__pos, yythunkpos51= yy->__thunkpos;  if (!yy_COMMA(yy)) goto l52;  goto l51;
  l52:;	  yy->__pos= yypos51; yy->__thunkpos= yythunkpos51;
  {  int yypos53= yy->__pos, yythunkpos53= yy->__thunkpos;  if (!yy_COMMA(yy)) goto l53;  goto l42;
  l53:;	  yy->__pos= yypos53; yy->__thunkpos= yythunkpos53;
  }  yyDo(yy, yy_5_expr_list, yy->__begin, yy->__end);
  }
  l51:;	
  yyprintf((stderr, "  ok   %s @ %s\n", "expr_list", yy->__buf+yy->__pos));  yyDo(yy, yyPop, 1, 0);
  return 1;
  l42:;	  yy->__pos= yypos0; yy->__thunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "expr_list", yy->__buf+yy->__pos));
  return 0;
}
YY_RULE(int) yy_number(yycontext *yy)
{  int yypos0= yy->__pos, yythunkpos0= yy->__thunkpos;
  yyprintf((stderr, "%s\n", "number"));  yyText(yy, yy->__begin, yy->__end);  {
#define yytext yy->__text
#define yyleng yy->__textlen
if (!(YY_BEGIN)) goto l54;
#undef yytext
#undef yyleng
  }  if (!yy_digit(yy)) goto l54;
  l55:;	
  {  int yypos56= yy->__pos, yythunkpos56= yy->__thunkpos;  if (!yy_digit(yy)) goto l56;  goto l55;
  l56:;	  yy->__pos= yypos56; yy->__thunkpos= yythunkpos56;
  }  yyText(yy, yy->__begin, yy->__end);  {
#define yytext yy->__text
#define yyleng yy->__textlen
if (!(YY_END)) goto l54;
#undef yytext
#undef yyleng
  }  if (!yy__(yy)) goto l54;  yyDo(yy, yy_1_number, yy->__begin, yy->__end);
  yyprintf((stderr, "  ok   %s @ %s\n", "number", yy->__buf+yy->__pos));
  return 1;
  l54:;	  yy->__pos= yypos0; yy->__thunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "number", yy->__buf+yy->__pos));
  return 0;
}
YY_RULE(int) yy_CR(yycontext *yy)
{  int yypos0= yy->__pos, yythunkpos0= yy->__thunkpos;
  yyprintf((stderr, "%s\n", "CR"));
  {  int yypos58= yy->__pos, yythunkpos58= yy->__thunkpos;  if (!yymatchChar(yy, '\n')) goto l59;  goto l58;
  l59:;	  yy->__pos= yypos58; yy->__thunkpos= yythunkpos58;  if (!yymatchChar(yy, '\r')) goto l60;  goto l58;
  l60:;	  yy->__pos= yypos58; yy->__thunkpos= yythunkpos58;  if (!yymatchString(yy, "\r\n")) goto l57;
  }
  l58:;	
  yyprintf((stderr, "  ok   %s @ %s\n", "CR", yy->__buf+yy->__pos));
  return 1;
  l57:;	  yy->__pos= yypos0; yy->__thunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "CR", yy->__buf+yy->__pos));
  return 0;
}
YY_RULE(int) yy_statement(yycontext *yy)
{  int yypos0= yy->__pos, yythunkpos0= yy->__thunkpos;  yyDo(yy, yyPush, 6, 0);
  yyprintf((stderr, "%s\n", "statement"));
  {  int yypos62= yy->__pos, yythunkpos62= yy->__thunkpos;  if (!yymatchString(yy, "print")) goto l63;  if (!yy__(yy)) goto l63;  if (!yy_expr_list(yy)) goto l63;  goto l62;
  l63:;	  yy->__pos= yypos62; yy->__thunkpos= yythunkpos62;  if (!yymatchString(yy, "if")) goto l64;  if (!yy__(yy)) goto l64;  if (!yy_expression(yy)) goto l64;  yyDo(yy, yySet, -6, 0);  if (!yy_relop(yy)) goto l64;  yyDo(yy, yySet, -5, 0);  if (!yy_expression(yy)) goto l64;  yyDo(yy, yySet, -4, 0);  yyDo(yy, yy_1_statement, yy->__begin, yy->__end);  if (!yymatchString(yy, "then")) goto l64;  if (!yy__(yy)) goto l64;  if (!yy_statement(yy)) goto l64;  goto l62;
  l64:;	  yy->__pos= yypos62; yy->__thunkpos= yythunkpos62;  if (!yymatchString(yy, "goto")) goto l65;  if (!yy__(yy)) goto l65;  if (!yy_expression(yy)) goto l65;  yyDo(yy, yySet, -3, 0);  yyDo(yy, yy_2_statement, yy->__begin, yy->__end);  goto l62;
  l65:;	  yy->__pos= yypos62; yy->__thunkpos= yythunkpos62;  if (!yymatchString(yy, "input")) goto l66;  if (!yy__(yy)) goto l66;  if (!yy_var_list(yy)) goto l66;  goto l62;
  l66:;	  yy->__pos= yypos62; yy->__thunkpos= yythunkpos62;  if (!yymatchString(yy, "let")) goto l67;  if (!yy__(yy)) goto l67;  if (!yy_var(yy)) goto l67;  yyDo(yy, yySet, -2, 0);  if (!yy_EQUAL(yy)) goto l67;  if (!yy_expression(yy)) goto l67;  yyDo(yy, yySet, -3, 0);  yyDo(yy, yy_3_statement, yy->__begin, yy->__end);  goto l62;
  l67:;	  yy->__pos= yypos62; yy->__thunkpos= yythunkpos62;  if (!yymatchString(yy, "gosub")) goto l68;  if (!yy__(yy)) goto l68;  if (!yy_expression(yy)) goto l68;  yyDo(yy, yySet, -3, 0);  yyDo(yy, yy_4_statement, yy->__begin, yy->__end);  goto l62;
  l68:;	  yy->__pos= yypos62; yy->__thunkpos= yythunkpos62;  if (!yymatchString(yy, "return")) goto l69;  if (!yy__(yy)) goto l69;  yyDo(yy, yy_5_statement, yy->__begin, yy->__end);  goto l62;
  l69:;	  yy->__pos= yypos62; yy->__thunkpos= yythunkpos62;  if (!yymatchString(yy, "clear")) goto l70;  if (!yy__(yy)) goto l70;  yyDo(yy, yy_6_statement, yy->__begin, yy->__end);  goto l62;
  l70:;	  yy->__pos= yypos62; yy->__thunkpos= yythunkpos62;  if (!yymatchString(yy, "list")) goto l71;  if (!yy__(yy)) goto l71;  yyDo(yy, yy_7_statement, yy->__begin, yy->__end);  goto l62;
  l71:;	  yy->__pos= yypos62; yy->__thunkpos= yythunkpos62;  if (!yymatchString(yy, "run")) goto l72;  if (!yy__(yy)) goto l72;  if (!yy_string(yy)) goto l72;  yyDo(yy, yySet, -1, 0);  yyDo(yy, yy_8_statement, yy->__begin, yy->__end);  goto l62;
  l72:;	  yy->__pos= yypos62; yy->__thunkpos= yythunkpos62;  if (!yymatchString(yy, "run")) goto l73;  if (!yy__(yy)) goto l73;  yyDo(yy, yy_9_statement, yy->__begin, yy->__end);  goto l62;
  l73:;	  yy->__pos= yypos62; yy->__thunkpos= yythunkpos62;  if (!yymatchString(yy, "end")) goto l74;  if (!yy__(yy)) goto l74;  yyDo(yy, yy_10_statement, yy->__begin, yy->__end);  goto l62;
  l74:;	  yy->__pos= yypos62; yy->__thunkpos= yythunkpos62;  if (!yymatchString(yy, "rem")) goto l75;  if (!yy__(yy)) goto l75;
  l76:;	
  {  int yypos77= yy->__pos, yythunkpos77= yy->__thunkpos;
  {  int yypos78= yy->__pos, yythunkpos78= yy->__thunkpos;  if (!yy_CR(yy)) goto l78;  goto l77;
  l78:;	  yy->__pos= yypos78; yy->__thunkpos= yythunkpos78;
  }  if (!yymatchDot(yy)) goto l77;  goto l76;
  l77:;	  yy->__pos= yypos77; yy->__thunkpos= yythunkpos77;
  }  goto l62;
  l75:;	  yy->__pos= yypos62; yy->__thunkpos= yythunkpos62;
  {  int yypos80= yy->__pos, yythunkpos80= yy->__thunkpos;  if (!yymatchString(yy, "bye")) goto l81;  goto l80;
  l81:;	  yy->__pos= yypos80; yy->__thunkpos= yythunkpos80;  if (!yymatchString(yy, "quit")) goto l82;  goto l80;
  l82:;	  yy->__pos= yypos80; yy->__thunkpos= yythunkpos80;  if (!yymatchString(yy, "exit")) goto l79;
  }
  l80:;	  if (!yy__(yy)) goto l79;  yyDo(yy, yy_11_statement, yy->__begin, yy->__end);  goto l62;
  l79:;	  yy->__pos= yypos62; yy->__thunkpos= yythunkpos62;  if (!yymatchString(yy, "save")) goto l83;  if (!yy__(yy)) goto l83;  if (!yy_string(yy)) goto l83;  yyDo(yy, yySet, -1, 0);  yyDo(yy, yy_12_statement, yy->__begin, yy->__end);  goto l62;
  l83:;	  yy->__pos= yypos62; yy->__thunkpos= yythunkpos62;  if (!yymatchString(yy, "load")) goto l84;  if (!yy__(yy)) goto l84;  if (!yy_string(yy)) goto l84;  yyDo(yy, yySet, -1, 0);  yyDo(yy, yy_13_statement, yy->__begin, yy->__end);  goto l62;
  l84:;	  yy->__pos= yypos62; yy->__thunkpos= yythunkpos62;  if (!yymatchString(yy, "type")) goto l85;  if (!yy__(yy)) goto l85;  if (!yy_string(yy)) goto l85;  yyDo(yy, yySet, -1, 0);  yyDo(yy, yy_14_statement, yy->__begin, yy->__end);  goto l62;
  l85:;	  yy->__pos= yypos62; yy->__thunkpos= yythunkpos62;  if (!yymatchString(yy, "dir")) goto l86;  if (!yy__(yy)) goto l86;  yyDo(yy, yy_15_statement, yy->__begin, yy->__end);  goto l62;
  l86:;	  yy->__pos= yypos62; yy->__thunkpos= yythunkpos62;  if (!yymatchString(yy, "help")) goto l61;  if (!yy__(yy)) goto l61;  yyDo(yy, yy_16_statement, yy->__begin, yy->__end);
  }
  l62:;	
  yyprintf((stderr, "  ok   %s @ %s\n", "statement", yy->__buf+yy->__pos));  yyDo(yy, yyPop, 6, 0);
  return 1;
  l61:;	  yy->__pos= yypos0; yy->__thunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "statement", yy->__buf+yy->__pos));
  return 0;
}
YY_RULE(int) yy__(yycontext *yy)
{
  yyprintf((stderr, "%s\n", "_"));
  l88:;	
  {  int yypos89= yy->__pos, yythunkpos89= yy->__thunkpos;  if (!yymatchClass(yy, (unsigned char *)"\000\002\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l89;  goto l88;
  l89:;	  yy->__pos= yypos89; yy->__thunkpos= yythunkpos89;
  }
  yyprintf((stderr, "  ok   %s @ %s\n", "_", yy->__buf+yy->__pos));
  return 1;
}
YY_RULE(int) yy_line(yycontext *yy)
{  int yypos0= yy->__pos, yythunkpos0= yy->__thunkpos;  yyDo(yy, yyPush, 2, 0);
  yyprintf((stderr, "%s\n", "line"));
  {  int yypos91= yy->__pos, yythunkpos91= yy->__thunkpos;  if (!yy__(yy)) goto l92;  if (!yy_statement(yy)) goto l92;  yyDo(yy, yySet, -2, 0);  if (!yy_CR(yy)) goto l92;  goto l91;
  l92:;	  yy->__pos= yypos91; yy->__thunkpos= yythunkpos91;  if (!yy__(yy)) goto l93;  if (!yy_number(yy)) goto l93;  yyDo(yy, yySet, -1, 0);  yyText(yy, yy->__begin, yy->__end);  {
#define yytext yy->__text
#define yyleng yy->__textlen
if (!(YY_BEGIN)) goto l93;
#undef yytext
#undef yyleng
  }
  l94:;	
  {  int yypos95= yy->__pos, yythunkpos95= yy->__thunkpos;
  {  int yypos96= yy->__pos, yythunkpos96= yy->__thunkpos;  if (!yy_CR(yy)) goto l96;  goto l95;
  l96:;	  yy->__pos= yypos96; yy->__thunkpos= yythunkpos96;
  }  if (!yymatchDot(yy)) goto l95;  goto l94;
  l95:;	  yy->__pos= yypos95; yy->__thunkpos= yythunkpos95;
  }  if (!yy_CR(yy)) goto l93;  yyText(yy, yy->__begin, yy->__end);  {
#define yytext yy->__text
#define yyleng yy->__textlen
if (!(YY_END)) goto l93;
#undef yytext
#undef yyleng
  }  yyDo(yy, yy_1_line, yy->__begin, yy->__end);  goto l91;
  l93:;	  yy->__pos= yypos91; yy->__thunkpos= yythunkpos91;  if (!yy__(yy)) goto l97;  if (!yy_CR(yy)) goto l97;  goto l91;
  l97:;	  yy->__pos= yypos91; yy->__thunkpos= yythunkpos91;  if (!yy__(yy)) goto l98;  yyText(yy, yy->__begin, yy->__end);  {
#define yytext yy->__text
#define yyleng yy->__textlen
if (!(YY_BEGIN)) goto l98;
#undef yytext
#undef yyleng
  }
  l99:;	
  {  int yypos100= yy->__pos, yythunkpos100= yy->__thunkpos;
  {  int yypos101= yy->__pos, yythunkpos101= yy->__thunkpos;  if (!yy_CR(yy)) goto l101;  goto l100;
  l101:;	  yy->__pos= yypos101; yy->__thunkpos= yythunkpos101;
  }  if (!yymatchDot(yy)) goto l100;  goto l99;
  l100:;	  yy->__pos= yypos100; yy->__thunkpos= yythunkpos100;
  }  if (!yy_CR(yy)) goto l98;  yyText(yy, yy->__begin, yy->__end);  {
#define yytext yy->__text
#define yyleng yy->__textlen
if (!(YY_END)) goto l98;
#undef yytext
#undef yyleng
  }  yyDo(yy, yy_2_line, yy->__begin, yy->__end);  goto l91;
  l98:;	  yy->__pos= yypos91; yy->__thunkpos= yythunkpos91;  if (!yy__(yy)) goto l90;
  {  int yypos102= yy->__pos, yythunkpos102= yy->__thunkpos;  if (!yymatchDot(yy)) goto l102;  goto l90;
  l102:;	  yy->__pos= yypos102; yy->__thunkpos= yythunkpos102;
  }  yyDo(yy, yy_3_line, yy->__begin, yy->__end);
  }
  l91:;	
  yyprintf((stderr, "  ok   %s @ %s\n", "line", yy->__buf+yy->__pos));  yyDo(yy, yyPop, 2, 0);
  return 1;
  l90:;	  yy->__pos= yypos0; yy->__thunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "line", yy->__buf+yy->__pos));
  return 0;
}

#ifndef YY_PART

typedef int (*yyrule)(yycontext *yy);

YY_PARSE(int) YYPARSEFROM(YY_CTX_PARAM_ yyrule yystart)
{
  int yyok;
  if (!yyctx->__buflen)
    {
      yyctx->__buflen= YY_BUFFER_SIZE;
      yyctx->__buf= (char *)YY_MALLOC(yyctx, yyctx->__buflen);
      yyctx->__textlen= YY_BUFFER_SIZE;
      yyctx->__text= (char *)YY_MALLOC(yyctx, yyctx->__textlen);
      yyctx->__thunkslen= YY_STACK_SIZE;
      yyctx->__thunks= (yythunk *)YY_MALLOC(yyctx, sizeof(yythunk) * yyctx->__thunkslen);
      yyctx->__valslen= YY_STACK_SIZE;
      yyctx->__vals= (YYSTYPE *)YY_MALLOC(yyctx, sizeof(YYSTYPE) * yyctx->__valslen);
      yyctx->__begin= yyctx->__end= yyctx->__pos= yyctx->__limit= yyctx->__thunkpos= 0;
    }
  yyctx->__begin= yyctx->__end= yyctx->__pos;
  yyctx->__thunkpos= 0;
  yyctx->__val= yyctx->__vals;
  yyok= yystart(yyctx);
  if (yyok) yyDone(yyctx);
  yyCommit(yyctx);
  if (0) {
    yyAccept (NULL, 0);
  }
  return yyok;
}

YY_PARSE(int) YYPARSE(YY_CTX_PARAM)
{
  return YYPARSEFROM(YY_CTX_ARG_ yy_line);
}

YY_PARSE(yycontext *) YYRELEASE(yycontext *yyctx)
{
  if (yyctx->__buflen)
    {
      yyctx->__buflen= 0;
      YY_FREE(yyctx, yyctx->__buf);
      YY_FREE(yyctx, yyctx->__text);
      YY_FREE(yyctx, yyctx->__thunks);
      YY_FREE(yyctx, yyctx->__vals);
    }
  return yyctx;
}

#endif
#line 165 "basic.leg"


#include <unistd.h>
#include <stdarg.h>

char *help=
  "print <num>|<string> [, <num>|<string> ...] [,]\n"
  "if <expr> <|<=|<>|=|>=|> <expr> then <stmt>\n"
  "input <var> [, <var> ...]     let <var> = <expr>\n"
  "goto <expr>                   gosub <expr>\n"
  "end                           return\n"
  "list                          clear\n"
  "run [\"filename\"]              rem <comment...>\n"
  "dir                           type \"filename\"\n"
  "save \"filename\"               load \"filename\"\n"
  "bye|quit|exit                 help\n"
  ;

void error(char *fmt, ...)
{
  va_list ap;
  va_start(ap, fmt);
  if (epc > 0)
    fprintf(stderr, "\nline %d: %s", lines[epc-1].number, lines[epc-1].text);
  else
    fprintf(stderr, "\n");
  vfprintf(stderr, fmt, ap);
  fprintf(stderr, "\n");
  va_end(ap);
  epc= pc= -1;
}

#ifdef USE_READLINE
# include <readline/readline.h>
# include <readline/history.h>
#endif

int nextline(char *buf, int max)
{
  pc= -1;
  if (batch) exit(0);
  if (isatty(fileno(stdin)))
    {
#    ifdef USE_READLINE
      char *line= readline(">");
      if (line)
	{
	  int len= strlen(line);
	  if (len >= max) len= max - 1;
	  strncpy(buf, line, len);
	  (buf)[len]= '\n';
	  add_history(line);
	  free(line);
	  return len + 1;
	}
      else
	{
	  printf("\n");
	  return 0;
	}
#    endif
      putchar('>');
      fflush(stdout);
    }
  return fgets(buf, max, stdin) ? strlen(buf) : 0;
}

int maxLines= 0;

int findLine(int n, int create)
{
  int lo= 0, hi= numLines - 1;
  while (lo <= hi)
    {
      int mid= (lo + hi) / 2, lno= lines[mid].number;
      if (lno > n)
	hi= mid - 1;
      else if (lno < n)
	lo= mid + 1;
      else
	return mid;
    }
  if (create)
    {
      if (numLines == maxLines)
	{
	  maxLines *= 2;
	  lines= realloc(lines, sizeof(line) * maxLines);
	}
      if (lo < numLines)
	memmove(lines + lo + 1, lines + lo, sizeof(line) * (numLines - lo));
      ++numLines;
      lines[lo].number= n;
      lines[lo].text= 0;
      return lo;
    }
  return -1;
}

void accept(int n, char *s)
{
  if (s[0] < 32)	/* delete */
    {
      int lno= findLine(n, 0);
      if (lno >= 0)
	{
	  if (lno < numLines - 1)
	    memmove(lines + lno, lines + lno + 1, sizeof(line) * (numLines - lno - 1));
	  --numLines;
	}
    }
  else			/* insert */
    {
      int lno= findLine(n, 1);
      if (lines[lno].text) free(lines[lno].text);
      lines[lno].length= strlen(s);
      lines[lno].text= strdup(s);
    }
}

char *extend(char *name)
{
  static char path[1024];
  int len= strlen(name);
  sprintf(path, "%s%s", name, (((len > 4) && !strcasecmp(".bas", name + len - 4)) ? "" : ".bas"));
  return path;
}

void save(char *name)
{
  FILE *f= fopen(name= extend(name), "w");
  if (!f)
    perror(name);
  else
    {
      int i;
      for (i= 0;  i < numLines;  ++i)
	fprintf(f, "%d %s", lines[i].number, lines[i].text);
      fclose(f);
    }
}

void load(char *name)
{
  FILE *f= fopen(name= extend(name), "r");
  if (!f)
    perror(name);
  else
    {
      int  lineNumber;
      char lineText[1024];
      while ((1 == fscanf(f, " %d ", &lineNumber)) && fgets(lineText, sizeof(lineText), f))
	accept(lineNumber, lineText);
      fclose(f);
    }
}

void type(char *name)
{
  FILE *f= fopen(name= extend(name), "r");
  if (!f)
    perror(name);
  else
    {
      int  c, d;
      while ((c= getc(f)) >= 0)
	putchar(d= c);
      fclose(f);
      if ('\n' != d && '\r' != d) putchar('\n');
    }
}

int input(void)
{
  char line[32];
  fgets(line, sizeof(line), stdin);
  return atoi(line);
}

int main(int argc, char **argv)
{
  lines= malloc(sizeof(line) * (maxLines= 32));
  numLines= 0;

  if (argc > 1)
    {
      batch= 1;
      while (argc-- > 1)
	load(*++argv);
      pc= 0;
    }

  while (!feof(stdin))
    yyparse();

  return 0;
}

